ANN Regression¶

df = pd.read_csv("data/Clean_Dataset.csv")
df = df.drop(['Unnamed: 0'], axis = 1)
print("\n================== HEAD DO DATASET ==================\n")
display(df.head())
print("\n=====================================================\n")
print("\n================== SHAPE DO DATASET ==================\n")
display(df.shape)
print("\n=====================================================\n")
display(df.dtypes)
print("\n================== VISUALIZANDO VALORES NULOS ==================\n")
null_summary = df.isnull().sum().to_frame().rename(columns={0: 'Null Count'})
null_summary['Percentage'] = (null_summary['Null Count'] / len(df)) * 100
display(null_summary)
print("\n=====================================================\n")

# Todas possíveis variáveis categóricas
cat_features = [column for column in df.columns if df[column].dtype in ["object", "category", "bool"]]

# Numéricas mas na verdade são categóricas
num_but_cat_features = [column for column in df.columns if (df[column].dtype in ["int64", "float64"]) and (df[column].nunique() < 9)]

# Variáveis categóricas
categoric_features = cat_features + num_but_cat_features
categoric_features = [column for column in categoric_features]

df[categoric_features]

sns.set_style("whitegrid")
sns.set_context("talk") 
palette_colors = "Set2" 

plt.figure(figsize=(20,32))

plt.subplot(4, 2, 1)
sns.countplot(x=df["airline"], data=df, legend=False)
plt.title("Frequency of Airline")
sns.despine() 

plt.subplot(4, 2, 2)
sns.countplot(x=df["source_city"], data=df, palette=palette_colors, 
              hue=df["source_city"], legend=False) 
plt.title("Frequency of Source City")
sns.despine() 

plt.subplot(4, 2, 3)
sns.countplot(x=df["departure_time"], data=df, palette=palette_colors, 
              hue=df["departure_time"], legend=False)
plt.title("Frequency of Departure Time")
sns.despine() 

plt.subplot(4, 2, 4)
sns.countplot(x=df["stops"], data=df, palette="deep", 
              hue=df["stops"], legend=False) 
plt.title("Frequency of Stops")
sns.despine() 

plt.subplot(4, 2, 5)
sns.countplot(x=df["arrival_time"], data=df, palette=palette_colors, 
              hue=df["arrival_time"], legend=False)
plt.title("Frequency of Arrival Time")
sns.despine() 

plt.subplot(4, 2, 6)
sns.countplot(x=df["destination_city"], data=df, palette=palette_colors, 
              hue=df["destination_city"], legend=False)
plt.title("Frequency of Destination City")
sns.despine() 

plt.subplot(4, 2, 7)
sns.countplot(x=df["class"], data=df, palette="pastel", 
              hue=df["class"], legend=False) 
plt.title("Class Frequency")
sns.despine() 

plt.tight_layout() 
plt.show()

numeric_features = [column for column in df.columns if (df[column].dtype in ["int64", "float64"]) and (column not in categoric_features)]

df[numeric_features]

plt.figure(figsize=(20,6))

for i, col in enumerate(["duration", "days_left", "price"], 1):
    plt.subplot(1, 3, i)
    sns.histplot(df[col], kde=True, color="skyblue", bins=30)
    plt.title(f"Distribuição de {col.capitalize()}", fontsize=14)
    plt.xlabel(col.capitalize())
    plt.ylabel("Frequência")

plt.tight_layout()
plt.show()

corr = df[
    [c for c in numeric_features if not c.startswith('Unnamed')]
].corr()

plt.figure(figsize=(7, 6))

cmap = sns.color_palette("vlag", as_cmap=True) 

ax = sns.heatmap(
    corr,
    cmap=cmap,
    vmin=-1, vmax=1, center=0,       
    annot=True, fmt=".2f",            
    annot_kws={"size":8},
    square=True,
    linewidths=0.4, linecolor="white",
    cbar_kws={"shrink":0.8, "label":"Pearson r"},
)

plt.xticks(rotation=45, ha="right")
plt.yticks(rotation=0)
plt.title("Matriz de Correlação (Pearson)")
plt.tight_layout()
plt.show()

df["stops"] = df["stops"].replace({'zero': 0,
                                   'one': 1,
                                   'two_or_more': 2})

df["class"] = df["class"].replace({'Economy': 0,
                                   'Business': 1})

# One Hot Encoding
dummies_variables = ["airline", "source_city", "departure_time", "arrival_time", "destination_city"]
dummies = pd.get_dummies(df[dummies_variables], drop_first= True)

df = pd.concat([df, dummies], axis=1)
df = df.drop(dummies_variables + ['flight'], axis=1) # Excluindo colunas antigas antes do one hot.

df.head()

df.shape

corr = df.corr(numeric_only=True)
plt.figure(figsize=(35, 25))
ax = sns.heatmap(
    corr,                      
    annot=True, fmt=".2f",
    vmin=-1.0, vmax=1.0, center=0,
    cmap="vlag",             
    square=True,
    linewidths=0.4, linecolor="white",
    cbar_kws={"shrink": 0.8, "label": "Pearson r"},
)

plt.xticks(rotation=45, ha="right")
plt.yticks(rotation=0)
plt.title("Matriz de Correlação")
plt.tight_layout()
plt.show()

X_train, X_tmp, y_train, y_tmp = train_test_split(X, y, test_size=0.30, random_state=SEED)
X_val,   X_test, y_val, y_test = train_test_split(X_tmp, y_tmp, test_size=0.50, random_state=SEED)

print(f"Train ({(len(X_train)/len(X)):.2f}): {len(X_train)} | Val ({len(X_val)/len(X):.2f}): {len(X_val)} | Test ({len(X_test)/len(X):.2f}): {len(X_test)}")

X_train

# Scaling APÓS o split (sem tocar na variável-alvo)
from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler()
num_vars = ['duration', 'days_left']  # ⬅️ não inclui 'price'

# Ajusta no treino e aplica em val/test (sem vazamento)
X_train.loc[:, num_vars] = scaler.fit_transform(X_train[num_vars])
X_val.loc[:,   num_vars] = scaler.transform(X_val[num_vars])
X_test.loc[:,  num_vars] = scaler.transform(X_test[num_vars])

import numpy as np
import matplotlib.pyplot as plt
from math import sqrt

X_train_base = X_train   
X_val_base = X_val   
X_test_base = X_test

X_train = np.asarray(X_train_base, dtype=float)
X_val   = np.asarray(X_val_base,   dtype=float)
X_test  = np.asarray(X_test_base,  dtype=float)

y_train = np.asarray(y_train, dtype=float).ravel()
y_val   = np.asarray(y_val,   dtype=float).ravel()
y_test  = np.asarray(y_test,  dtype=float).ravel()

y_train_col = y_train.reshape(-1, 1)
y_val_col   = y_val.reshape(-1, 1)

N, D = X_train.shape

# 1) Métricas de regressão
def metrics(y_true, y_pred):
    y_true = np.asarray(y_true).ravel(); y_pred = np.asarray(y_pred).ravel()
    mae  = np.mean(np.abs(y_true - y_pred))
    rmse = sqrt(np.mean((y_true - y_pred)**2))
    ss_res = np.sum((y_true - y_pred)**2)
    ss_tot = np.sum((y_true - np.mean(y_true))**2)
    r2 = 1 - ss_res/ss_tot if ss_tot > 0 else np.nan
    return {"MAE": mae, "RMSE": rmse, "R2": r2}

# 2) Arquitetura: ReLU 128→64→1 (linear)
rng = np.random.default_rng(42)
H1, H2 = 32, 16

W1 = rng.standard_normal((H1, D)) * np.sqrt(2.0 / D)
b1 = np.zeros((1, H1))

W2 = rng.standard_normal((H2, H1)) * np.sqrt(2.0 / H1) 
b2 = np.zeros((1, H2))

W3 = rng.standard_normal((1, H2)) * np.sqrt(2.0 / H2)
b3 = np.zeros((1, 1))

def relu(x):    
    return np.maximum(0, x)

def relu_d(x):  
    return (x > 0).astype(x.dtype)

def forward(X):
    Z1 = X @ W1.T + b1; A1 = relu(Z1)
    Z2 = A1 @ W2.T + b2; A2 = relu(Z2)
    Y  = A2 @ W3.T + b3          # saída linear (regressão)
    return Z1, A1, Z2, A2, Y

# 3) Treino: Adam + MSE
lr = 1e-3
epochs = 100
batch  = 128

beta1, beta2, eps = 0.9, 0.999, 1e-8

# Adam buffers
mW1 = np.zeros_like(W1) 
vW1 = np.zeros_like(W1)

mW2 = np.zeros_like(W2)
vW2 = np.zeros_like(W2)

mW3 = np.zeros_like(W3)
vW3 = np.zeros_like(W3)

mb1 = np.zeros_like(b1)
vb1 = np.zeros_like(b1)

mb2 = np.zeros_like(b2) 
vb2 = np.zeros_like(b2)

mb3 = np.zeros_like(b3)
vb3 = np.zeros_like(b3)

t = 0

def adam_update(param, grad, m, v):
    m = beta1*m + (1-beta1)*grad
    v = beta2*v + (1-beta2)*(grad*grad)
    m_hat = m / (1 - beta1**t)
    v_hat = v / (1 - beta2**t)
    param -= lr * m_hat / (np.sqrt(v_hat) + eps)
    return param, m, v

train_losses, val_losses = [], []

for ep in range(1, epochs+1):
    idx = rng.permutation(N)
    epoch_loss = 0.0

    for i in range(0, N, batch):
        bidx = idx[i:i+batch]
        xb = X_train[bidx]
        yb = y_train_col[bidx]
        B  = xb.shape[0]

        #  forward 
        Z1, A1, Z2, A2, Yp = forward(xb)

        #  loss (MSE)
        mse = np.mean((Yp - yb)**2)
        epoch_loss += mse * B

        #  backprop 
        d3  = (2.0/B) * (Yp - yb)     # (B,1)
        gW3 = d3.T @ A2               # (1,H2)
        gb3 = d3.sum(axis=0, keepdims=True)

        dA2 = d3 @ W3                 # (B,H2)
        dZ2 = dA2 * relu_d(Z2)
        gW2 = dZ2.T @ A1              # (H2,H1)
        gb2 = dZ2.sum(axis=0, keepdims=True)

        dA1 = dZ2 @ W2                # (B,H1)
        dZ1 = dA1 * relu_d(Z1)
        gW1 = dZ1.T @ xb              # (H1,D)
        gb1 = dZ1.sum(axis=0, keepdims=True)

        #  Adam step (incrementa t uma vez por batch) 
        t += 1
        W3, mW3, vW3 = adam_update(W3, gW3, mW3, vW3)
        b3, mb3, vb3 = adam_update(b3, gb3, mb3, vb3)
        W2, mW2, vW2 = adam_update(W2, gW2, mW2, vW2)
        b2, mb2, vb2 = adam_update(b2, gb2, mb2, vb2)
        W1, mW1, vW1 = adam_update(W1, gW1, mW1, vW1)
        b1, mb1, vb1 = adam_update(b1, gb1, mb1, vb1)

    epoch_loss /= N
    train_losses.append(epoch_loss)

    # validação
    _, _, _, _, Yv = forward(X_val)
    val_mse = np.mean((Yv - y_val_col)**2)
    val_losses.append(val_mse)

    print(f"Época {ep:02d} | Train MSE {epoch_loss:.4f} | Val MSE {val_mse:.4f}")

# 4) Avaliação e gráficos
def predict(X):
    _, _, _, _, Y = forward(X)
    return Y.ravel()

pred_val  = predict(X_val)
pred_test = predict(X_test)

print("Val :", metrics(y_val,  pred_val))
print("Test:", metrics(y_test, pred_test))

plt.figure(figsize=(10,4))
plt.subplot(1,2,1)
plt.plot(train_losses, label="Train")
plt.plot(val_losses,   label="Val")
plt.xlabel("Épocas"); plt.ylabel("MSE"); plt.title("Curva de Loss"); plt.legend()

plt.subplot(1,2,2)
plt.scatter(y_val, pred_val, s=8, alpha=0.4)
lims = [min(y_val.min(), pred_val.min()), max(y_val.max(), pred_val.max())]
plt.plot(lims, lims, "--")
plt.xlabel("Verdadeiro"); plt.ylabel("Previsto"); plt.title("Val: y_true vs y_pred")
plt.tight_layout(); plt.show()

from math import sqrt
import matplotlib.pyplot as plt
plt.rcParams.update({
    "font.size": 10,
    "axes.titlesize": 12,
    "axes.labelsize": 10,
    "xtick.labelsize": 9,
    "ytick.labelsize": 9,
    "legend.fontsize": 9,
    "figure.titlesize": 13
})

# Funções auxiliares de métricas
def _to1d(a):
    a = np.asarray(a, dtype=float)
    return a.ravel() if a.ndim > 1 else a

def mape(y_true, y_pred, eps=1e-8):
    y_true = np.asarray(y_true, dtype=float)
    denom = np.maximum(np.abs(y_true), eps)
    return np.mean(np.abs((y_true - y_pred) / denom)) * 100.0

def smape(y_true, y_pred, eps=1e-8):
    y_true = np.asarray(y_true, dtype=float)
    y_pred = np.asarray(y_pred, dtype=float)
    denom = np.maximum((np.abs(y_true) + np.abs(y_pred)) / 2, eps)
    return np.mean(np.abs(y_true - y_pred) / denom) * 100.0

def r2_score_np(y_true, y_pred):
    y_true = np.asarray(y_true, dtype=float)
    ss_res = np.sum((y_true - y_pred)**2)
    ss_tot = np.sum((y_true - np.mean(y_true))**2)
    return 1 - ss_res/ss_tot if ss_tot > 0 else np.nan

# Dados e previsões
X_val   = np.asarray(X_val, dtype=float)
X_test  = np.asarray(X_test, dtype=float)
y_train = _to1d(y_train)
y_val   = _to1d(y_val)
y_test  = _to1d(y_test)

y_pred_val  = _to1d(predict(X_val))
y_pred_test = _to1d(predict(X_test))

baseline_val  = np.full_like(y_val,  fill_value=float(np.mean(y_train)), dtype=float)
baseline_test = np.full_like(y_test, fill_value=float(np.mean(y_train)), dtype=float)

# Função de métricas gerais
def print_metrics(title, y_true, y_pred, y_base):
    mae  = np.mean(np.abs(y_true - y_pred))
    mse  = np.mean((y_true - y_pred)**2)
    rmse = sqrt(mse)
    r2   = r2_score_np(y_true, y_pred)
    mp   = mape(y_true, y_pred)
    smp  = smape(y_true, y_pred)

    mae_b  = np.mean(np.abs(y_true - y_base))
    mse_b  = np.mean((y_true - y_base)**2)
    rmse_b = sqrt(mse_b)
    r2_b   = r2_score_np(y_true, y_base)
    mp_b   = mape(y_true, y_base)
    smp_b  = smape(y_true, y_base)

    print(f"\n=== {title} ===")
    print("Metric           Model         Baseline(mean y_train)")
    print(f"MAE      :   {mae:10.4f}   {mae_b:10.4f}")
    print(f"MSE      :   {mse:10.4f}   {mse_b:10.4f}")
    print(f"RMSE     :   {rmse:10.4f}   {rmse_b:10.4f}")
    print(f"R2       :   {r2:10.4f}   {r2_b:10.4f}")
    print(f"MAPE(%)  :   {mp:10.4f}   {mp_b:10.4f}")
    print(f"sMAPE(%) :   {smp:10.4f}   {smp_b:10.4f}")

print_metrics("Validation", y_val,  y_pred_val,  baseline_val)
print_metrics("Test",       y_test, y_pred_test, baseline_test)

# ------------------------------------------------------------
train_acc = 1 - np.array(train_losses) / np.max(train_losses)
val_acc   = 1 - np.array(val_losses) / np.max(val_losses)

ss_tot_val = np.sum((y_val - np.mean(y_val))**2)
r2_by_epoch = [1 - (mse * len(y_val)) / ss_tot_val for mse in val_losses]

final_mse_test = np.mean((y_pred_test - y_test)**2)
test_acc = 1 - final_mse_test / np.max(train_losses)

plt.figure(figsize=(15,4))

plt.subplot(1,3,1)
plt.plot(train_losses, label="Train Loss")
plt.plot(val_losses, label="Val Loss")
plt.xlabel("Épocas"); plt.ylabel("MSE")
plt.title("Curva de Loss por Época")
plt.legend()

plt.subplot(1,3,2)
plt.plot(train_acc, label="Train Accuracy (1 - Loss Normalizada)")
plt.plot(val_acc, label="Val Accuracy (1 - Loss Normalizada)")
plt.hlines(test_acc, 0, len(train_acc)-1, colors='orange', linestyles='--', label=f"Test Accuracy ({test_acc:.3f})")
plt.xlabel("Épocas"); plt.ylabel("Acurácia (Normalizada)")
plt.title("Acurácia por Época (Train / Val / Test)")
plt.legend()

plt.subplot(1,3,3)
plt.plot(r2_by_epoch, color='green', label="R² (Val)")
plt.xlabel("Épocas"); plt.ylabel("R²")
plt.title("R² por Época (Validação)")
plt.ylim(0, 1.05)
plt.legend()

plt.tight_layout()
plt.show()

# 2) Gráficos de resíduos e previsão x real
res_val = y_val - y_pred_val
plt.figure(figsize=(10,4))
plt.subplot(1,2,1)
plt.scatter(y_pred_val, res_val, alpha=0.6)
plt.axhline(0, linestyle="--")
plt.xlabel("Predicted (val)"); plt.ylabel("Residuals")
plt.title("Residual Plot (Val)")

plt.subplot(1,2,2)
plt.scatter(y_val, y_pred_val, alpha=0.6)
mn = float(min(np.min(y_val), np.min(y_pred_val)))
mx = float(max(np.max(y_val), np.max(y_pred_val)))
plt.plot([mn, mx], [mn, mx], linestyle="--")
plt.xlabel("Actual (y_val)"); plt.ylabel("Predicted (val)")
plt.title("Actual vs Predicted (Val)")
plt.tight_layout()
plt.show()

res_test = y_test - y_pred_test
plt.figure(figsize=(10,4))
plt.subplot(1,2,1)
plt.scatter(y_pred_test, res_test, alpha=0.6)
plt.axhline(0, linestyle="--")
plt.xlabel("Predicted (test)"); plt.ylabel("Residuals")
plt.title("Residual Plot (Test)")

plt.subplot(1,2,2)
plt.scatter(y_test, y_pred_test, alpha=0.6)
mn = float(min(np.min(y_test), np.min(y_pred_test)))
mx = float(max(np.max(y_test), np.max(y_pred_test)))
plt.plot([mn, mx], [mn, mx], linestyle="--")
plt.xlabel("Actual (y_test)"); plt.ylabel("Predicted (test)")
plt.title("Actual vs Predicted (Test)")
plt.tight_layout()
plt.show()